Electronic systems and circuits have made a significant contribution towards the advancement of modern society and are utilized in a number of applications to achieve advantageous results. Numerous electronic technologies such as digital computers, calculators, audio devices, video equipment, and telephone systems have facilitated increased productivity and reduced costs in analyzing and communicating information in most areas of business, science, education and entertainment. Systems providing these advantageous results often involve emulation of a virtual “machine” for processing information. Emulation application information that directs processing activities is typically very large and is often revised or updated for a variety of reasons. However, storing and communicating large amounts of emulation application information requires significant resources. Furthermore, revising and updating existing emulation application information can be difficult and are often problematic.
Numerous electronic devices include processors that operate by executing programs comprising a series of instructions. These programs and their series of instructions are typically referred to as software. Software instructions include directions that guide processor device functions in the performance of useful tasks. The software code is often expressed in different configurations or languages. Some software is expressed in an emulation language and runs on a virtual machine. JAVA is one example of a high level emulation language that offers significant advantages. JAVA characteristics of platform independence, security, and network mobility make it particularly suitable for emerging distributed network computing environments. While JAVA applications can provide significant advantages, storing, communicating and revising or updating a JAVA application information can consume significant resources.
Emulation applications are typically object oriented programs and often include code segments that are large. The code segments usually include bytecode and data (e.g., configured in class definitions). The bytecode designators (e.g., class names, method names, field names, operands, constants, etc.) are usually long textual strings comprising numerous characters and often duplicative. This usually results in a requirement for numerous bits to express or represent the information. The larger the number of bits that are communicated, processed and/or stored the greater the resources required. Communicating larger number of bits often requires increased network infrastructure to achieve desirable bandwidth and/or network resource are used or occupied (e.g., “consumed” in the sense that they are unavailable for other activities) for a longer duration. Processing the information also usually requires more resources dedicated to processing activities (e.g., larger registers for storing bytecode designators). Finally, storing larger number of bits usually involves resources committed to memories (e.g., a greater number of memory cells for the additional bits). In addition to requiring more resources the longer code also usually entails longer access and execution times that slow performance down.
It is also traditionally difficult to maintain data consistency when revising emulation code. One traditional approach to attempt data consistency or coherency is to shut down an emulation virtual machine before a revision or update to emulation application information is made. For example, JAVA virtual machines are shut down before the new classes (e.g., revised classes) are reloaded in place of the old ones. This usually requires the entire application to be loaded again and processing started over. This is particularly inconvenient if the emulation virtual machine has been running an application for a relatively long period of time. The relative nature of the time between revisions is usually determined based upon the application. For example, if an application performs numerous operations in a second, several minutes can be a relatively long lived application with respect to application processing. If the emulation virtual machine has been running for a while there can be a significant number of application threads that involve information “reprocessing”.
Further complicating the revision of traditional emulation code is the relatively large number of bits that may require alteration in a change. Since the number of bits used to internally express or represent traditional emulation code and constants are usually large, the number of bits that require alteration to change traditional emulation internal representation information is also usually large. In addition, the typically high incidence of duplicated code and/or lengthy code strings further exacerbates the problem.